home *** CD-ROM | disk | FTP | other *** search
/ Cre@te Online 2000 December / Cre@teOnline CD05.iso / MacSoft / XML ConsoleMax.sea / XML ConsoleMax / Required / swingall.jar / javax / swing / tree / VariableHeightLayoutCache.class (.txt) < prev    next >
Encoding:
Java Class File  |  1999-07-15  |  12.1 KB  |  661 lines
  1. package javax.swing.tree;
  2.  
  3. import java.awt.Rectangle;
  4. import java.util.Enumeration;
  5. import java.util.Hashtable;
  6. import java.util.Stack;
  7. import java.util.Vector;
  8. import javax.swing.event.TreeModelEvent;
  9.  
  10. public class VariableHeightLayoutCache extends AbstractLayoutCache {
  11.    private Vector visibleNodes = new Vector();
  12.    private boolean updateNodeSizes;
  13.    private TreeStateNode root;
  14.    private Rectangle boundsBuffer = new Rectangle();
  15.    private Hashtable treePathMapping = new Hashtable();
  16.    private Stack tempStacks = new Stack();
  17.  
  18.    // $FF: synthetic method
  19.    static void access$0(VariableHeightLayoutCache var0, TreeStateNode var1) {
  20.       var0.addMapping(var1);
  21.    }
  22.  
  23.    // $FF: synthetic method
  24.    static Vector access$1(VariableHeightLayoutCache var0) {
  25.       return var0.visibleNodes;
  26.    }
  27.  
  28.    // $FF: synthetic method
  29.    static TreeStateNode access$2(VariableHeightLayoutCache var0) {
  30.       return var0.root;
  31.    }
  32.  
  33.    // $FF: synthetic method
  34.    static void access$3(VariableHeightLayoutCache var0, TreeStateNode var1) {
  35.       var0.removeMapping(var1);
  36.    }
  37.  
  38.    // $FF: synthetic method
  39.    static Rectangle access$4(VariableHeightLayoutCache var0) {
  40.       return var0.boundsBuffer;
  41.    }
  42.  
  43.    // $FF: synthetic method
  44.    static boolean access$5(VariableHeightLayoutCache var0) {
  45.       return var0.updateNodeSizes;
  46.    }
  47.  
  48.    // $FF: synthetic method
  49.    static void access$6(VariableHeightLayoutCache var0, boolean var1) {
  50.       var0.updateNodeSizes = var1;
  51.    }
  52.  
  53.    // $FF: synthetic method
  54.    static TreeStateNode access$7(VariableHeightLayoutCache var0, Object var1) {
  55.       return var0.createNodeForValue(var1);
  56.    }
  57.  
  58.    // $FF: synthetic method
  59.    static void access$8(VariableHeightLayoutCache var0) {
  60.       var0.visibleNodesChanged();
  61.    }
  62.  
  63.    private void addMapping(TreeStateNode var1) {
  64.       this.treePathMapping.put(var1.getTreePath(), var1);
  65.    }
  66.  
  67.    private TreeStateNode createNodeAt(TreeStateNode var1, int var2) {
  68.       Object var4 = super.treeModel.getChild(var1.getValue(), var2);
  69.       TreeStateNode var5 = this.createNodeForValue(var4);
  70.       ((DefaultMutableTreeNode)var1).insert(var5, var2);
  71.       var5.updatePreferredSize(-1);
  72.       boolean var3 = var1 == this.root;
  73.       if (var5 != null && var1.isExpanded() && (var1.getRow() != -1 || var3)) {
  74.          int var6;
  75.          if (var2 == 0) {
  76.             if (var3 && !((AbstractLayoutCache)this).isRootVisible()) {
  77.                var6 = 0;
  78.             } else {
  79.                var6 = var1.getRow() + 1;
  80.             }
  81.          } else if (var2 == ((DefaultMutableTreeNode)var1).getChildCount()) {
  82.             var6 = var1.getLastVisibleNode().getRow() + 1;
  83.          } else {
  84.             TreeStateNode var7 = (TreeStateNode)((DefaultMutableTreeNode)var1).getChildAt(var2 - 1);
  85.             var6 = var7.getLastVisibleNode().getRow() + 1;
  86.          }
  87.  
  88.          this.visibleNodes.insertElementAt(var5, var6);
  89.       }
  90.  
  91.       return var5;
  92.    }
  93.  
  94.    private TreeStateNode createNodeForValue(Object var1) {
  95.       return new TreeStateNode(this, var1);
  96.    }
  97.  
  98.    private void ensurePathIsExpanded(TreePath var1, boolean var2) {
  99.       if (var1 != null) {
  100.          if (super.treeModel.isLeaf(var1.getLastPathComponent())) {
  101.             var1 = var1.getParentPath();
  102.             var2 = true;
  103.          }
  104.  
  105.          if (var1 != null) {
  106.             TreeStateNode var3 = this.getNodeForPath(var1, false, true);
  107.             if (var3 != null) {
  108.                var3.makeVisible();
  109.                if (var2) {
  110.                   var3.expand();
  111.                }
  112.             }
  113.          }
  114.       }
  115.  
  116.    }
  117.  
  118.    private Rectangle getBounds(int var1, Rectangle var2) {
  119.       if (this.updateNodeSizes) {
  120.          this.updateNodeSizes(false);
  121.       }
  122.  
  123.       return var1 >= 0 && var1 < this.getRowCount() ? this.getNode(var1).getNodeBounds(var2) : null;
  124.    }
  125.  
  126.    public Rectangle getBounds(TreePath var1, Rectangle var2) {
  127.       TreeStateNode var3 = this.getNodeForPath(var1, true, false);
  128.       if (var3 != null) {
  129.          if (this.updateNodeSizes) {
  130.             this.updateNodeSizes(false);
  131.          }
  132.  
  133.          return var3.getNodeBounds(var2);
  134.       } else {
  135.          return null;
  136.       }
  137.    }
  138.  
  139.    public boolean getExpandedState(TreePath var1) {
  140.       TreeStateNode var2 = this.getNodeForPath(var1, true, false);
  141.       return var2 != null ? var2.isVisible() && var2.isExpanded() : false;
  142.    }
  143.  
  144.    private TreeStateNode getMapping(TreePath var1) {
  145.       return (TreeStateNode)this.treePathMapping.get(var1);
  146.    }
  147.  
  148.    private int getMaxNodeWidth() {
  149.       int var1 = 0;
  150.  
  151.       for(int var3 = this.getRowCount() - 1; var3 >= 0; --var3) {
  152.          TreeStateNode var4 = this.getNode(var3);
  153.          int var2 = var4.getPreferredWidth() + var4.getXOrigin();
  154.          if (var2 > var1) {
  155.             var1 = var2;
  156.          }
  157.       }
  158.  
  159.       return var1;
  160.    }
  161.  
  162.    private TreeStateNode getNode(int var1) {
  163.       return (TreeStateNode)this.visibleNodes.elementAt(var1);
  164.    }
  165.  
  166.    private TreeStateNode getNodeForPath(TreePath var1, boolean var2, boolean var3) {
  167.       if (var1 != null) {
  168.          TreeStateNode var4 = this.getMapping(var1);
  169.          if (var4 != null) {
  170.             if (var2 && !var4.isVisible()) {
  171.                return null;
  172.             } else {
  173.                return var4;
  174.             }
  175.          } else {
  176.             Stack var5;
  177.             if (this.tempStacks.size() == 0) {
  178.                var5 = new Stack();
  179.             } else {
  180.                var5 = (Stack)this.tempStacks.pop();
  181.             }
  182.  
  183.             try {
  184.                var5.push(var1);
  185.                var1 = var1.getParentPath();
  186.  
  187.                for(Object var14 = null; var1 != null; var1 = var1.getParentPath()) {
  188.                   var4 = this.getMapping(var1);
  189.                   if (var4 != null) {
  190.                      while(var4 != null && ((Vector)var5).size() > 0) {
  191.                         var1 = (TreePath)var5.pop();
  192.                         var4.getLoadedChildren(var3);
  193.                         int var9 = super.treeModel.getIndexOfChild(((DefaultMutableTreeNode)var4).getUserObject(), var1.getLastPathComponent());
  194.                         if (var9 != -1 && var9 < ((DefaultMutableTreeNode)var4).getChildCount() && (!var2 || var4.isVisible())) {
  195.                            var4 = (TreeStateNode)((DefaultMutableTreeNode)var4).getChildAt(var9);
  196.                         } else {
  197.                            var4 = null;
  198.                         }
  199.                      }
  200.  
  201.                      TreeStateNode var6 = var4;
  202.                      return var6;
  203.                   }
  204.  
  205.                   var5.push(var1);
  206.                }
  207.  
  208.                return null;
  209.             } finally {
  210.                ((Vector)var5).removeAllElements();
  211.                this.tempStacks.push(var5);
  212.             }
  213.          }
  214.       } else {
  215.          return null;
  216.       }
  217.    }
  218.  
  219.    public TreePath getPathClosestTo(int var1, int var2) {
  220.       if (this.getRowCount() == 0) {
  221.          return null;
  222.       } else {
  223.          if (this.updateNodeSizes) {
  224.             this.updateNodeSizes(false);
  225.          }
  226.  
  227.          int var3 = this.getRowContainingYLocation(var2);
  228.          return this.getNode(var3).getTreePath();
  229.       }
  230.    }
  231.  
  232.    public TreePath getPathForRow(int var1) {
  233.       return var1 >= 0 && var1 < this.getRowCount() ? this.getNode(var1).getTreePath() : null;
  234.    }
  235.  
  236.    public int getPreferredWidth(Rectangle var1) {
  237.       if (this.updateNodeSizes) {
  238.          this.updateNodeSizes(false);
  239.       }
  240.  
  241.       return this.getMaxNodeWidth();
  242.    }
  243.  
  244.    private int getRowContainingYLocation(int var1) {
  245.       if (((AbstractLayoutCache)this).isFixedRowHeight()) {
  246.          return this.getRowCount() == 0 ? -1 : Math.max(0, Math.min(this.getRowCount() - 1, var1 / ((AbstractLayoutCache)this).getRowHeight()));
  247.       } else {
  248.          int var2;
  249.          if ((var2 = this.getRowCount()) <= 0) {
  250.             return -1;
  251.          } else {
  252.             int var5 = 0;
  253.             int var4 = 0;
  254.  
  255.             while(var5 < var2) {
  256.                var4 = (var2 - var5) / 2 + var5;
  257.                TreeStateNode var7 = (TreeStateNode)this.visibleNodes.elementAt(var4);
  258.                int var6 = var7.getYOrigin();
  259.                int var3 = var6 + var7.getPreferredHeight();
  260.                if (var1 < var6) {
  261.                   var2 = var4 - 1;
  262.                } else {
  263.                   if (var1 < var3) {
  264.                      break;
  265.                   }
  266.  
  267.                   var5 = var4 + 1;
  268.                }
  269.             }
  270.  
  271.             if (var5 == var2) {
  272.                var4 = var5;
  273.                if (var5 >= this.getRowCount()) {
  274.                   var4 = this.getRowCount() - 1;
  275.                }
  276.             }
  277.  
  278.             return var4;
  279.          }
  280.       }
  281.    }
  282.  
  283.    public int getRowCount() {
  284.       return this.visibleNodes.size();
  285.    }
  286.  
  287.    public int getRowForPath(TreePath var1) {
  288.       if (var1 == null) {
  289.          return -1;
  290.       } else {
  291.          TreeStateNode var2 = this.getNodeForPath(var1, true, false);
  292.          return var2 != null ? var2.getRow() : -1;
  293.       }
  294.    }
  295.  
  296.    public int getVisibleChildCount(TreePath var1) {
  297.       TreeStateNode var2 = this.getNodeForPath(var1, true, false);
  298.       return var2 != null ? var2.getVisibleChildCount() : 0;
  299.    }
  300.  
  301.    public Enumeration getVisiblePathsFrom(TreePath var1) {
  302.       TreeStateNode var2 = this.getNodeForPath(var1, true, false);
  303.       return var2 != null ? new VisibleTreeStateNodeEnumeration(this, var2) : null;
  304.    }
  305.  
  306.    public void invalidatePathBounds(TreePath var1) {
  307.       TreeStateNode var2 = this.getNodeForPath(var1, true, false);
  308.       if (var2 != null) {
  309.          var2.markSizeInvalid();
  310.          if (var2.isVisible()) {
  311.             this.updateYLocationsFrom(var2.getRow());
  312.          }
  313.       }
  314.  
  315.    }
  316.  
  317.    public void invalidateSizes() {
  318.       if (this.root != null) {
  319.          this.root.deepMarkSizeInvalid();
  320.       }
  321.  
  322.       if (!((AbstractLayoutCache)this).isFixedRowHeight() && this.visibleNodes.size() > 0) {
  323.          this.updateNodeSizes(true);
  324.       }
  325.  
  326.    }
  327.  
  328.    public boolean isExpanded(TreePath var1) {
  329.       if (var1 == null) {
  330.          return false;
  331.       } else {
  332.          TreeStateNode var2 = this.getNodeForPath(var1, true, false);
  333.          return var2 != null && var2.isExpanded();
  334.       }
  335.    }
  336.  
  337.    private void rebuild() {
  338.       this.treePathMapping.clear();
  339.       if (super.treeModel != null) {
  340.          Object var1 = super.treeModel.getRoot();
  341.          this.root = this.createNodeForValue(var1);
  342.          this.root.path = new TreePath(var1);
  343.          this.addMapping(this.root);
  344.          this.root.updatePreferredSize(0);
  345.          this.visibleNodes.removeAllElements();
  346.          if (((AbstractLayoutCache)this).isRootVisible()) {
  347.             this.visibleNodes.addElement(this.root);
  348.          }
  349.  
  350.          if (!this.root.isExpanded()) {
  351.             this.root.expand();
  352.          } else {
  353.             Enumeration var2 = this.root.children();
  354.  
  355.             while(var2.hasMoreElements()) {
  356.                this.visibleNodes.addElement(var2.nextElement());
  357.             }
  358.  
  359.             if (!((AbstractLayoutCache)this).isFixedRowHeight()) {
  360.                this.updateYLocationsFrom(0);
  361.             }
  362.          }
  363.       } else {
  364.          this.visibleNodes.removeAllElements();
  365.          this.root = null;
  366.       }
  367.  
  368.       if (super.treeSelectionModel != null) {
  369.          super.treeSelectionModel.clearSelection();
  370.       }
  371.  
  372.       this.visibleNodesChanged();
  373.    }
  374.  
  375.    private void removeMapping(TreeStateNode var1) {
  376.       this.treePathMapping.remove(var1.getTreePath());
  377.    }
  378.  
  379.    public void setExpandedState(TreePath var1, boolean var2) {
  380.       if (var1 != null) {
  381.          if (var2) {
  382.             this.ensurePathIsExpanded(var1, true);
  383.          } else {
  384.             TreeStateNode var3 = this.getNodeForPath(var1, false, true);
  385.             if (var3 != null) {
  386.                var3.makeVisible();
  387.                var3.collapse();
  388.             }
  389.          }
  390.       }
  391.  
  392.    }
  393.  
  394.    public void setModel(TreeModel var1) {
  395.       super.setModel(var1);
  396.       this.rebuild();
  397.    }
  398.  
  399.    public void setNodeDimensions(AbstractLayoutCache.NodeDimensions var1) {
  400.       super.setNodeDimensions(var1);
  401.       this.invalidateSizes();
  402.       this.visibleNodesChanged();
  403.    }
  404.  
  405.    public void setRootVisible(boolean var1) {
  406.       if (((AbstractLayoutCache)this).isRootVisible() != var1 && this.root != null) {
  407.          if (var1) {
  408.             this.root.updatePreferredSize(0);
  409.             this.visibleNodes.insertElementAt(this.root, 0);
  410.          } else if (this.visibleNodes.size() > 0) {
  411.             this.visibleNodes.removeElementAt(0);
  412.             if (super.treeSelectionModel != null) {
  413.                super.treeSelectionModel.removeSelectionPath(this.root.getTreePath());
  414.             }
  415.          }
  416.  
  417.          if (super.treeSelectionModel != null) {
  418.             super.treeSelectionModel.resetRowSelection();
  419.          }
  420.  
  421.          if (this.getRowCount() > 0) {
  422.             this.getNode(0).setYOrigin(0);
  423.          }
  424.  
  425.          this.updateYLocationsFrom(0);
  426.          this.visibleNodesChanged();
  427.       }
  428.  
  429.       super.setRootVisible(var1);
  430.    }
  431.  
  432.    public void setRowHeight(int var1) {
  433.       if (var1 != ((AbstractLayoutCache)this).getRowHeight()) {
  434.          super.setRowHeight(var1);
  435.          this.invalidateSizes();
  436.          this.visibleNodesChanged();
  437.       }
  438.  
  439.    }
  440.  
  441.    public void treeNodesChanged(TreeModelEvent var1) {
  442.       if (var1 != null) {
  443.          int[] var2 = var1.getChildIndices();
  444.          TreeStateNode var3 = this.getNodeForPath(var1.getTreePath(), false, false);
  445.          if (var3 != null) {
  446.             Object var4 = var3.getValue();
  447.             var3.updatePreferredSize();
  448.             if (var3.hasBeenExpanded() && var2 != null) {
  449.                for(int var5 = 0; var5 < var2.length; ++var5) {
  450.                   TreeStateNode var6 = (TreeStateNode)((DefaultMutableTreeNode)var3).getChildAt(var2[var5]);
  451.                   var6.setUserObject(super.treeModel.getChild(var4, var2[var5]));
  452.                   var6.updatePreferredSize();
  453.                }
  454.             } else if (var3 == this.root) {
  455.                var3.updatePreferredSize();
  456.             }
  457.  
  458.             if (!((AbstractLayoutCache)this).isFixedRowHeight()) {
  459.                int var7 = var3.getRow();
  460.                if (var7 != -1) {
  461.                   this.updateYLocationsFrom(var7);
  462.                }
  463.             }
  464.  
  465.             this.visibleNodesChanged();
  466.          }
  467.       }
  468.  
  469.    }
  470.  
  471.    public void treeNodesInserted(TreeModelEvent var1) {
  472.       if (var1 != null) {
  473.          int[] var2 = var1.getChildIndices();
  474.          TreeStateNode var3 = this.getNodeForPath(var1.getTreePath(), false, false);
  475.          if (var3 != null && var2 != null && var2.length > 0) {
  476.             if (var3.hasBeenExpanded()) {
  477.                int var8 = ((DefaultMutableTreeNode)var3).getChildCount();
  478.                Object var6 = var3.getValue();
  479.                boolean var4 = var3 == this.root && !super.rootVisible || var3.getRow() != -1 && var3.isExpanded();
  480.  
  481.                for(int var5 = 0; var5 < var2.length; ++var5) {
  482.                   this.createNodeAt(var3, var2[var5]);
  483.                }
  484.  
  485.                if (var8 == 0) {
  486.                   var3.updatePreferredSize();
  487.                }
  488.  
  489.                if (super.treeSelectionModel != null) {
  490.                   super.treeSelectionModel.resetRowSelection();
  491.                }
  492.  
  493.                if (!((AbstractLayoutCache)this).isFixedRowHeight() && (var4 || var8 == 0 && var3.isVisible())) {
  494.                   if (var3 == this.root) {
  495.                      this.updateYLocationsFrom(0);
  496.                   } else {
  497.                      this.updateYLocationsFrom(var3.getRow());
  498.                   }
  499.  
  500.                   this.visibleNodesChanged();
  501.                } else if (var4) {
  502.                   this.visibleNodesChanged();
  503.                }
  504.             } else if (super.treeModel.getChildCount(var3.getValue()) - var2.length == 0) {
  505.                var3.updatePreferredSize();
  506.                if (!((AbstractLayoutCache)this).isFixedRowHeight() && var3.isVisible()) {
  507.                   this.updateYLocationsFrom(var3.getRow());
  508.                }
  509.             }
  510.          }
  511.       }
  512.  
  513.    }
  514.  
  515.    public void treeNodesRemoved(TreeModelEvent var1) {
  516.       if (var1 != null) {
  517.          int[] var2 = var1.getChildIndices();
  518.          TreeStateNode var3 = this.getNodeForPath(var1.getTreePath(), false, false);
  519.          if (var3 != null && var2 != null && var2.length > 0) {
  520.             if (var3.hasBeenExpanded()) {
  521.                boolean var4 = var3 == this.root && !super.rootVisible || var3.getRow() != -1 && var3.isExpanded();
  522.  
  523.                for(int var5 = var2.length - 1; var5 >= 0; --var5) {
  524.                   TreeStateNode var7 = (TreeStateNode)((DefaultMutableTreeNode)var3).getChildAt(var2[var5]);
  525.                   if (var7.isExpanded()) {
  526.                      var7.collapse(false);
  527.                   }
  528.  
  529.                   if (var4) {
  530.                      int var6 = var7.getRow();
  531.                      if (var6 != -1) {
  532.                         this.visibleNodes.removeElementAt(var6);
  533.                         if (super.treeSelectionModel != null) {
  534.                            TreePath var8 = var7.getTreePath();
  535.                            super.treeSelectionModel.removeSelectionPath(var8);
  536.                         }
  537.                      }
  538.                   }
  539.  
  540.                   var3.remove(var2[var5]);
  541.                }
  542.  
  543.                if (((DefaultMutableTreeNode)var3).getChildCount() == 0) {
  544.                   var3.updatePreferredSize();
  545.                }
  546.  
  547.                if (super.treeSelectionModel != null) {
  548.                   super.treeSelectionModel.resetRowSelection();
  549.                }
  550.  
  551.                if (!((AbstractLayoutCache)this).isFixedRowHeight() && (var4 || ((DefaultMutableTreeNode)var3).getChildCount() == 0 && var3.isVisible())) {
  552.                   if (var3 == this.root) {
  553.                      if (this.getRowCount() > 0) {
  554.                         this.getNode(0).setYOrigin(0);
  555.                      }
  556.  
  557.                      this.updateYLocationsFrom(0);
  558.                   } else {
  559.                      this.updateYLocationsFrom(var3.getRow());
  560.                   }
  561.  
  562.                   this.visibleNodesChanged();
  563.                } else if (var4) {
  564.                   this.visibleNodesChanged();
  565.                }
  566.             } else if (super.treeModel.getChildCount(var3.getValue()) == 0) {
  567.                var3.updatePreferredSize();
  568.                if (!((AbstractLayoutCache)this).isFixedRowHeight() && var3.isVisible()) {
  569.                   this.updateYLocationsFrom(var3.getRow());
  570.                }
  571.             }
  572.          }
  573.       }
  574.  
  575.    }
  576.  
  577.    public void treeStructureChanged(TreeModelEvent var1) {
  578.       if (var1 != null) {
  579.          TreePath var2 = var1.getTreePath();
  580.          TreeStateNode var3 = this.getNodeForPath(var2, false, false);
  581.          if (var3 == null && var2 != null && var2.getPathCount() == 1) {
  582.             var3 = this.root;
  583.          }
  584.  
  585.          if (var3 != null) {
  586.             boolean var4 = var3.isExpanded();
  587.             boolean var5 = var3.getRow() != -1;
  588.             if (var3 == this.root) {
  589.                this.rebuild();
  590.             } else {
  591.                TreeStateNode var10 = (TreeStateNode)((DefaultMutableTreeNode)var3).getParent();
  592.                int var7 = ((DefaultMutableTreeNode)var10).getIndex(var3);
  593.                if (var5 && var4) {
  594.                   var3.collapse(false);
  595.                }
  596.  
  597.                if (var5) {
  598.                   this.visibleNodes.removeElement(var3);
  599.                }
  600.  
  601.                ((DefaultMutableTreeNode)var3).removeFromParent();
  602.                this.createNodeAt(var10, var7);
  603.                TreeStateNode var9 = (TreeStateNode)((DefaultMutableTreeNode)var10).getChildAt(var7);
  604.                if (var5 && var4) {
  605.                   var9.expand(false);
  606.                }
  607.  
  608.                int var6 = var9.getRow();
  609.                if (!((AbstractLayoutCache)this).isFixedRowHeight() && var5) {
  610.                   if (var6 == 0) {
  611.                      this.updateYLocationsFrom(var6);
  612.                   } else {
  613.                      this.updateYLocationsFrom(var6 - 1);
  614.                   }
  615.  
  616.                   this.visibleNodesChanged();
  617.                } else if (var5) {
  618.                   this.visibleNodesChanged();
  619.                }
  620.             }
  621.          }
  622.       }
  623.  
  624.    }
  625.  
  626.    private void updateNodeSizes(boolean var1) {
  627.       this.updateNodeSizes = false;
  628.       int var3 = 0;
  629.       int var2 = 0;
  630.  
  631.       for(int var4 = this.visibleNodes.size(); var3 < var4; ++var3) {
  632.          TreeStateNode var5 = (TreeStateNode)this.visibleNodes.elementAt(var3);
  633.          var5.setYOrigin(var2);
  634.          if (var1 || !var5.hasValidSize()) {
  635.             var5.updatePreferredSize(var3);
  636.          }
  637.  
  638.          var2 += var5.getPreferredHeight();
  639.       }
  640.  
  641.    }
  642.  
  643.    private void updateYLocationsFrom(int var1) {
  644.       if (var1 >= 0 && var1 < this.getRowCount()) {
  645.          TreeStateNode var5 = this.getNode(var1);
  646.          int var4 = var5.getYOrigin() + var5.getPreferredHeight();
  647.          int var2 = var1 + 1;
  648.  
  649.          for(int var3 = this.visibleNodes.size(); var2 < var3; ++var2) {
  650.             var5 = (TreeStateNode)this.visibleNodes.elementAt(var2);
  651.             var5.setYOrigin(var4);
  652.             var4 += var5.getPreferredHeight();
  653.          }
  654.       }
  655.  
  656.    }
  657.  
  658.    private void visibleNodesChanged() {
  659.    }
  660. }
  661.